#pragma once

#include <algorithm>
#include <utility>
#include <assert.h>

#define JSON11_DCHECK assert

namespace json11 {

template <typename T>
class Optional final {
 public:
  // Construct an empty Optional.
  Optional() : has_value_(false) {}

  // Construct an Optional that contains a value.
  explicit Optional(const T& val) : value_(val), has_value_(true) {}
  explicit Optional(T&& val) : value_(std::move(val)), has_value_(true) {}

  // Copy and move constructors.
  // TODO(kwiberg): =default the move constructor when MSVC supports it.
  Optional(const Optional&) = default;
  Optional(Optional&& m)
      : value_(std::move(m.value_)), has_value_(m.has_value_) {}

  // Assignment.
  // TODO(kwiberg): =default the move assignment op when MSVC supports it.
  Optional& operator=(const Optional&) = default;
  Optional& operator=(Optional&& m) {
    value_ = std::move(m.value_);
    has_value_ = m.has_value_;
    return *this;
  }

  friend void swap(Optional& m1, Optional& m2) {
    using std::swap;
    swap(m1.value_, m2.value_);
    swap(m1.has_value_, m2.has_value_);
  }

  // Conversion to bool to test if we have a value.
  explicit operator bool() const { return has_value_; }

  // Dereferencing. Only allowed if we have a value.
  const T* operator->() const {
    JSON11_DCHECK(has_value_);
    return &value_;
  }
  T* operator->() {
	JSON11_DCHECK(has_value_);
    return &value_;
  }
  const T& operator*() const {
	JSON11_DCHECK(has_value_);
    return value_;
  }
  T& operator*() {
	JSON11_DCHECK(has_value_);
    return value_;
  }

  const T& value() const {
	JSON11_DCHECK(has_value_);
	return value_;
  }

  // Dereference with a default value in case we don't have a value.
  const T& value_or(const T& default_val) const {
    return has_value_ ? value_ : default_val;
  }

  // Equality tests. Two Optionals are equal if they contain equivalent values,
  // or
  // if they're both empty.
  friend bool operator==(const Optional& m1, const Optional& m2) {
    return m1.has_value_ && m2.has_value_ ? m1.value_ == m2.value_
                                          : m1.has_value_ == m2.has_value_;
  }
  friend bool operator!=(const Optional& m1, const Optional& m2) {
    return m1.has_value_ && m2.has_value_ ? m1.value_ != m2.value_
                                          : m1.has_value_ != m2.has_value_;
  }

 private:
  // Invariant: Unless *this has been moved from, value_ is default-initialized
  // (or copied or moved from a default-initialized T) if !has_value_.
  T value_;
  bool has_value_;
};

}  // namespace json11

